cortex/translations/zh.json-16-18 (1)

16-18: Remove extra keys not present in the English reference.

Lines 16-18 add keys (info, done, required_field) that don't exist in en.json. Per the translation guidelines in README.md, translations should not add or remove keys from the reference catalog.

Additional extra keys found:

• config.config_missing and config.config_readonly (lines 73-74)
• errors.permission_denied, errors.package_conflict, errors.installation_failed, errors.unknown_error (lines 87-90)

cortex/translations/ko.json-16-18 (1)

16-18: Remove extra keys not present in the English reference.

Lines 16-18 add keys (info, done, required_field) that don't exist in en.json. Per the translation guidelines in README.md, translations should not add or remove keys from the reference catalog.

Additional extra keys found:

• config.config_missing and config.config_readonly (lines 73-74)
• errors.permission_denied, errors.package_conflict, errors.installation_failed, errors.unknown_error (lines 87-90)

cortex/translations/README.md-16-29 (1)

16-29: Update language status table to reflect actual completion.

The status table shows Portuguese, French, Chinese, and German as "Not started" or "Planned", but the PR description indicates all 12 languages are complete, and translation files for zh.json, de.json, etc. are included in this PR.

🔎 Proposed fix

 | Code | Language | Status |
 |------|----------|--------|
 | en | English | Complete ✓ |
 | es | Español | Complete ✓ |
 | hi | हिन्दी | Complete ✓ |
 | ja | 日本語 | Complete ✓ |
 | ar | العربية | Complete ✓ |
-| pt | Português | Not started |
-| fr | Français | Not started |
-| zh | 中文 | Planned |
-| de | Deutsch | Planned |
+| pt | Português | Complete ✓ |
+| fr | Français | Complete ✓ |
+| de | Deutsch | Complete ✓ |
+| it | Italiano | Complete ✓ |
+| ru | Русский | Complete ✓ |
+| zh | 中文 | Complete ✓ |
+| ko | 한국어 | Complete ✓ |

cortex/translations/ru.json-1-147 (1)

1-147: Russian translation is incomplete with many English strings remaining.

The Russian translation follows the same pattern as Italian and German, with approximately 50% of strings still in English. While the pluralization rules are correctly implemented for Russian (line 33 shows proper one/few/other forms), the overall translation is incomplete.

Untranslated strings in common:

• Line 12: please_wait → should be "Пожалуйста, подождите..."
• Line 14: next → should be "Далее" or "Следующий"
• Line 15: exit → should be "Выход"

Entire sections still in English:

• Lines 21-27: cli section (all 7 keys)
• Lines 45-51: remove section (all 7 keys)
• Lines 54-62: search section (all 9 keys)
• Lines 93-97: prompts section (all 5 keys)
• Lines 100-106: status section (all 7 keys)
• Lines 109-114: wizard section (all 6 keys)
• Lines 117-123: history section (all 7 keys)
• Lines 141-145: demo section (all 5 keys)

Positive note: The Russian pluralization is correctly implemented with one/few/other forms (line 33), showing that language-specific rules were considered.

🔎 Quick validation check

#!/bin/bash
# Count English strings in Russian translation

echo "=== Checking Russian translation for English strings ==="
python3 << 'EOF'
import json
import re

with open('cortex/translations/ru.json', 'r', encoding='utf-8') as f:
    ru = json.load(f)

def has_english(text):
    # Simple heuristic: contains common English words
    english_words = ['Display', 'Show', 'Enable', 'Suppress', 'Preview', 'Force', 
                     'Output', 'format', 'Remove', 'Search', 'Install', 'Welcome',
                     'Select', 'Enter', 'Skip', 'History', 'Date', 'Action', 'Status']
    return any(word in text for word in english_words)

def check_dict(d, path=""):
    count = 0
    for key, value in d.items():
        current = f"{path}.{key}" if path else key
        if isinstance(value, dict):
            count += check_dict(value, current)
        elif isinstance(value, str) and has_english(value):
            print(f"  {current}: '{value}'")
            count += 1
    return count

english_count = check_dict(ru)
print(f"\nFound {english_count} strings with English content")
EOF

cortex/translations/it.json-1-147 (1)

1-147: Italian translation is incomplete with many English strings remaining.

The Italian translation file has significant portions still in English, which will result in a poor user experience for Italian speakers. Major untranslated sections include:

Untranslated strings in common:

• Line 12: please_wait → should be "Attendere..." or "Per favore, attendi..."
• Line 14: next → should be "Avanti" or "Successivo"
• Line 15: exit → should be "Esci" or "Uscita"

Entire sections still in English:

• Lines 21-27: cli section (help, version, verbose, quiet, dry_run, force, output_format)
• Lines 45-51: remove section (prompt, removing, success, failed, not_installed, dry_run, requires_confirmation)
• Lines 54-62: search section (all keys)
• Lines 93-97: prompts section (all keys)
• Lines 100-106: status section (all keys)
• Lines 109-114: wizard section (all keys)
• Lines 117-123: history section (all keys)
• Lines 141-145: demo section (all keys)

Partial translations in other sections:

• Lines 69-70: config.saved, config.reset
• Lines 78, 83, 85-86: Several errors keys

This contradicts the PR's claim of supporting 12 complete languages and being production-ready.

🔎 Verification script to compare against English source

#!/bin/bash
# Compare Italian translation completeness against English source

echo "=== Checking for English strings in Italian translation ==="
python3 << 'EOF'
import json
import sys

with open('cortex/translations/en.json', 'r', encoding='utf-8') as f:
    en = json.load(f)
with open('cortex/translations/it.json', 'r', encoding='utf-8') as f:
    it = json.load(f)

def compare_nested(en_dict, it_dict, path=""):
    untranslated = []
    for key, en_value in en_dict.items():
        current_path = f"{path}.{key}" if path else key
        if key not in it_dict:
            untranslated.append(f"MISSING: {current_path}")
        elif isinstance(en_value, dict):
            untranslated.extend(compare_nested(en_value, it_dict[key], current_path))
        elif isinstance(en_value, str) and isinstance(it_dict[key], str):
            # Check if Italian value is identical to English (likely untranslated)
            if en_value == it_dict[key] and len(en_value) > 3:
                untranslated.append(f"UNTRANSLATED: {current_path} = '{en_value}'")
    return untranslated

issues = compare_nested(en, it)
if issues:
    print(f"\nFound {len(issues)} untranslated or missing keys:\n")
    for issue in issues[:20]:  # Show first 20
        print(f"  {issue}")
    if len(issues) > 20:
        print(f"\n  ... and {len(issues) - 20} more")
    sys.exit(1)
else:
    print("✓ All keys translated")
EOF

Would you like me to generate a complete Italian translation for the missing sections, or should this be completed before merging the PR?

cortex/translations/de.json-1-147 (1)

1-147: German translation is incomplete with many English strings remaining.

The German translation file has the same pattern of incomplete translation as the Italian file, with approximately 50% of strings still in English.

Untranslated strings in common:

• Line 12: please_wait → should be "Bitte warten..."
• Line 14: next → should be "Weiter" or "Nächste"
• Line 15: exit → should be "Beenden" or "Verlassen"

Entire sections still in English:

• Lines 21-27: cli section (help, version, verbose, quiet, dry_run, force, output_format)
• Lines 45-51: remove section (all keys)
• Lines 54-62: search section (all keys)
• Lines 93-97: prompts section (all keys)
• Lines 100-106: status section (all keys)
• Lines 109-114: wizard section (all keys)
• Lines 117-123: history section (all keys)
• Lines 141-145: demo section (all keys)

Partial translations:

• Lines 69-70: config.saved, config.reset
• Lines 78, 83, 85-86: Several errors keys

This represents a systematic issue across multiple language files in this PR.

Would you like me to generate complete German translations for these missing sections?

I18N_TEST_REPORT.md-1-177 (1)

1-177: Test report validates only 5 languages despite PR claiming 12-language support.

The test report explicitly documents testing only 5 languages (English, Spanish, Japanese, Arabic, Hindi), while the Git commit title claims "comprehensive multi-language support for 12 languages." The repository contains 10 translation files (ar, de, en, es, hi, it, ja, ko, ru, zh), but the test suite only validates:

• ✓ English (en.json)
• ✓ Spanish (es.json)
• ✓ Japanese (ja.json)
• ✓ Arabic (ar.json)
• ✓ Hindi (hi.json)

Not explicitly tested in the documented test results:

• German (de.json)
• Italian (it.json)
• Russian (ru.json)
• Korean (ko.json)
• Chinese (zh.json)

The test report states it supports "5 languages" and "35/35 tests passed," but this coverage gap means untested languages may have issues (including incomplete or incorrect translations in the non-English files).

Expand test coverage to validate all 10 language files before marking as production-ready.

I18N_IMPLEMENTATION_SUMMARY.md-11-11 (1)

11-11: Documentation inconsistency: Language count mismatch.

The document states "7 languages out-of-the-box" but the PR objectives clearly indicate support for 12 languages: English, Spanish, Hindi, Japanese, Arabic, Portuguese, French, German, Italian, Russian, Chinese (Simplified), and Korean. This inconsistency appears throughout the document (lines 11, 54-66, 243-251, 525).

Please update the documentation to accurately reflect the actual number of supported languages and their completion status.

PR_DESCRIPTION.md-15-15 (1)

15-15: Language count inconsistency with PR objectives.

The document claims "7 Languages Supported Out-of-the-Box" (line 15) and the translation statistics (lines 393-399) show 5 complete + 2 pending languages. However, the PR objectives clearly state 12 languages are supported. Please reconcile this discrepancy across all documentation files.

Also applies to: 393-399

I18N_DELIVERABLES_INDEX.md-313-384 (1)

313-384: Language count inconsistency in translation files section.

Similar to I18N_IMPLEMENTATION_SUMMARY.md, this document lists only 5 complete translation files (en.json, es.json, hi.json, ja.json, ar.json) but the PR objectives state 12 languages are supported. The additional 7 language files (pt.json, fr.json, de.json, it.json, ru.json, zh.json, ko.json) mentioned in the PR summary are not documented here.

I18N_IMPLEMENTATION_SUMMARY.md-243-251 (1)

243-251: Update language coverage table to match PR scope.

The coverage table lists only 5 complete languages (English, Spanish, Hindi, Japanese, Arabic) with 2 pending (Portuguese, French), but doesn't mention the additional 5 languages stated in the PR objectives (German, Italian, Russian, Chinese, Korean).

cortex/i18n/language_manager.py-156-192 (1)

156-192: Deprecated function usage: locale.getdefaultlocale().

Line 165 uses locale.getdefaultlocale(), which is deprecated as of Python 3.11 and will be removed in Python 3.15. The coding guidelines specify Python 3.10+ as the minimum version, so this will cause issues for users on Python 3.11+.

Recommended fix using locale.getlocale()

 def get_system_language(self) -> Optional[str]:
     """
     Extract language from system locale settings.
     
     Returns:
         Language code if detected, None otherwise
     """
     try:
         # Get system locale
-        system_locale, _ = locale.getdefaultlocale()
+        system_locale, _ = locale.getlocale()
         
         if not system_locale:
             logger.debug("Could not determine system locale")
             return None

Note: locale.getlocale() returns the current locale settings. If you need to detect the user's preferred locale (rather than the currently set locale), consider using locale.getdefaultlocale() for Python <3.11 and locale.getlocale() for Python ≥3.11, or use environment variables like LANG directly.

scripts/validate_translations.py-187-221 (1)

187-221: Move import to module level and improve placeholder parsing.

Line 199 imports re inside the method, which violates PEP 8 guidelines. Additionally, the placeholder parsing logic (lines 206-207) that splits on commas could incorrectly handle complex placeholder syntax if commas appear in other contexts.

Recommended improvements

 """
 
 import json
+import re
 import sys
 from pathlib import Path
 from typing import Dict, List, Tuple

And for more robust placeholder handling:

     def _check_placeholders(
         self, en_val: str, cat_val: str, lang_code: str, key: str
     ) -> None:
         """
         Check that placeholders match between English and translation.
         
         Args:
             en_val: English value
             cat_val: Translated value
             lang_code: Language code
             key: Translation key
         """
-        import re
-        
         # Find all {placeholder} in English
         en_placeholders = set(re.findall(r"\{([^}]+)\}", en_val))
         cat_placeholders = set(re.findall(r"\{([^}]+)\}", cat_val))
         
-        # Remove plural syntax if present (e.g., "count, plural, one {...}")
-        en_placeholders = {p.split(",")[0] for p in en_placeholders}
-        cat_placeholders = {p.split(",")[0] for p in cat_placeholders}
+        # Extract variable names, handling plural syntax
+        # Format: {variable, plural, one {...} other {...}}
+        def extract_var_name(placeholder: str) -> str:
+            """Extract the variable name from a placeholder."""
+            parts = placeholder.split(",")
+            return parts[0].strip()
+        
+        en_placeholders = {extract_var_name(p) for p in en_placeholders}
+        cat_placeholders = {extract_var_name(p) for p in cat_placeholders}

Committable suggestion skipped: line range outside the PR's diff.

cortex/i18n/pluralization.py-14-43 (1)

14-43: Fix Arabic pluralization rule to use modulo operations per CLDR standard.

The implementation uses direct range checks instead of the CLDR-required modulo operations. Arabic plural rules must evaluate n % 100 (the last two digits):

• "few": n % 100 in 3..10
• "many": n % 100 in 11..99

Current code treats all numbers 11–99 as "many", but numbers ≥ 100 like 103 and 111 are incorrectly categorized as "other" instead of "few" and "many" respectively.

I18N_IMPLEMENTATION_PLAN.md-963-983 (1)

963-983: Remove or update dependency references inconsistent with implementation.

This section lists python-i18n>=0.3.9 as a dependency and provides installation instructions for it. However, the actual implementation uses stdlib only with zero external dependencies.

This planning document should be updated to either:

1. Note that the original plan used python-i18n but the implementation took a different approach, or
2. Remove the dependency references entirely to avoid confusion

I18N_IMPLEMENTATION_PLAN.md-9-21 (1)

9-21: Update architecture description - implementation uses stdlib, not python-i18n.

Line 11 states "This proposal introduces python-i18n as the core i18n framework," but the PR summary explicitly notes "Zero external dependencies (stdlib only)." This is a significant architectural difference between the plan and the actual implementation.

Consider updating this section to reflect that the implementation uses a custom stdlib-based solution rather than the python-i18n library.

I18N_QUICK_REFERENCE.md-309-320 (1)

309-320: Language support table is incomplete and inconsistent with PR contents.

The supported languages table (lines 311-319) lists only 7 languages and doesn't reflect the actual translation files added in this PR:

Documented in table:

• en, es, hi, ja, ar (marked complete)
• pt, fr (marked needed)

Files added in PR but not documented:

• de.json (German)
• it.json (Italian)
• ru.json (Russian)
• ko.json (Korean - mentioned in PR description)
• zh.json (Chinese - mentioned in PR description)

Additionally, the table marks German, Italian, and Russian as not present, but these files exist in the PR (albeit with incomplete translations).

🔎 Proposed update to language support table

 | Code | Language | Status |
 |------|----------|--------|
 | en | English | ✓ Complete |
 | es | Español | ✓ Complete |
 | hi | हिन्दी | ✓ Complete |
 | ja | 日本語 | ✓ Complete |
 | ar | العربية | ✓ Complete |
+| de | Deutsch | ⚠️ Partial |
+| it | Italiano | ⚠️ Partial |
+| ru | Русский | ⚠️ Partial |
+| ko | 한국어 | ✓ Complete |
+| zh | 中文 | ✓ Complete |
 | pt | Português | ⏳ Needed |
 | fr | Français | ⏳ Needed |

cortex/i18n/fallback_handler.py-20-39 (1)

20-39: Remove trailing whitespace from docstring blank lines.

Lines 23, 30, and 39 contain trailing whitespace. These should be removed to comply with PEP 8.

🔎 Proposed fix

 class FallbackHandler:
     """
     Manages fallback behavior when translations are missing.
-    
+
     Fallback Strategy:
     1. Return translated message in target language if available
     2. Fall back to English translation if target language unavailable
     3. Generate placeholder message using key name
     4. Log warning for missing translations
     5. Track missing keys for reporting
-    
+
     Example:
         >>> handler = FallbackHandler()
         >>> result = handler.handle_missing('install.new_key', 'es')
         >>> print(result)
         '[install.new_key]'
         >>> handler.get_missing_translations()
         {'install.new_key'}
     """
-    
+

cortex/i18n/fallback_handler.py-51-74 (1)

51-74: Remove trailing whitespace from blank lines.

Lines 54, 57, and 61 contain trailing whitespace. These should be removed to comply with PEP 8.

🔎 Proposed fix

     def handle_missing(self, key: str, language: str) -> str:
         """
         Handle missing translation gracefully.
-        
+
         When a translation key is not found, this returns a fallback
         and logs a warning for the development team.
-        
+
         Args:
             key: Translation key that was not found (e.g., 'install.success')
             language: Target language that was missing the key (e.g., 'es')
-            
+
         Returns:
             Fallback message: placeholder like '[install.success]'
         """

cortex/i18n/fallback_handler.py-103-147 (1)

103-147: Fix docstring inconsistency and consider using csv.writer.

The docstring on line 107 mentions a suggested_placeholder column, but the actual CSV header on line 128 only includes key,namespace. Update the docstring to match the implementation.

Additionally, while the manual CSV building works, consider using the imported csv module's writer for more robust CSV generation (handles escaping edge cases automatically).

🔎 Proposed fixes

Fix 1: Update docstring to match implementation

     def export_missing_for_translation(self, output_path: Optional[Path] = None) -> str:
         """
         Export missing translations as CSV for translator team.
         
-        Creates a CSV file with columns: key, namespace, suggested_placeholder
+        Creates a CSV file with columns: key, namespace
         This helps translator teams quickly identify gaps in translations.

Fix 2 (optional): Use csv.writer for robust CSV generation

         # Build CSV content
-        csv_lines = ["key,namespace"]
-        
-        for key in sorted(self.missing_keys):
-            # Extract namespace from key (e.g., 'install.success' -> 'install')
-            parts = key.split(".")
-            namespace = parts[0] if len(parts) > 0 else "unknown"
-            csv_lines.append(f'"{key}","{namespace}"')
-        
-        csv_content = "\n".join(csv_lines)
+        import io
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(["key", "namespace"])
+        
+        for key in sorted(self.missing_keys):
+            # Extract namespace from key (e.g., 'install.success' -> 'install')
+            namespace = key.split(".")[0] if "." in key else "unknown"
+            writer.writerow([key, namespace])
+        
+        csv_content = output.getvalue()

cortex/i18n/pluralization.py (1)

80-102: Consider handling edge cases for count parameter.

The get_plural_form method accepts count: int but doesn't handle edge cases:

• Negative numbers (e.g., -5)
• Zero for languages that don't have a "zero" form
• Very large numbers

While these may be rare in typical usage, explicit handling or documentation would improve robustness.

Suggested enhancement

 @classmethod
 def get_plural_form(cls, language: str, count: int) -> str:
     """
     Get plural form key for language and count.
     
     Args:
         language: Language code (e.g., 'en', 'es', 'ar')
         count: Numeric count for pluralization
         
     Returns:
         Plural form key ('one', 'few', 'many', 'other', etc.)
+    
+    Note:
+        Negative counts are treated as their absolute value.
+        Zero is handled according to language-specific rules.
         
     Example:
         >>> PluralRules.get_plural_form('en', 1)
         'one'
         >>> PluralRules.get_plural_form('en', 5)
         'other'
         >>> PluralRules.get_plural_form('ar', 0)
         'zero'
     """
+    # Handle negative counts
+    count = abs(count)
+    
     # Default to English rules if language not found
     rule = cls.RULES.get(language, cls.RULES["en"])
     return rule(count)

cortex/i18n/translator.py (1)

108-110: Weak pluralization detection logic.

Line 108 checks if "{" in message and "plural" in message: to detect pluralization syntax. This could produce false positives if:

• The message contains braces for other purposes
• The word "plural" appears in translated text
• Messages with multiple variables, one of which happens to be named "plural"

Consider a more specific pattern match or structured format.

Suggested improvement

     def get_plural(self, key: str, count: int, **kwargs) -> str:
         """
         Get pluralized translation.
         
         Handles pluralization based on language-specific rules.
         Expects message in format: "text {variable, plural, one {singular} other {plural}}"
         
         Args:
             key: Translation key with plural form
             count: Number for pluralization decision
             **kwargs: Additional format variables
             
         Returns:
             Correctly pluralized message
             
         Example:
             >>> translator.get_plural('install.downloading', 5, package_count=5)
             'Descargando 5 paquetes'
         """
         message = self.get(key, **kwargs)
         
         # Parse plural form if present
-        if "{" in message and "plural" in message:
+        # Look for pattern: {variable, plural, ...}
+        import re
+        if re.search(r'\{[^}]+,\s*plural\s*,', message):
             return self._parse_pluralization(message, count, self.language)
         
         return message

PR_DESCRIPTION.md (1)

11-11: Clarify external dependency status upfront.

Line 11 mentions using "python-i18n approach" which could be misinterpreted as using the python-i18n library. Line 575 clarifies "No new external dependencies!" and line 584 mentions python-i18n is optional. This clarification should come earlier in the document to avoid confusion.

Suggested improvement

 ## Overview
 
-This PR introduces comprehensive **multi-language (i18n) support** to Cortex Linux using the lightweight **python-i18n** approach with custom JSON-based translation catalogs. The implementation is modular, extensible, and requires zero breaking changes to existing code.
+This PR introduces comprehensive **multi-language (i18n) support** to Cortex Linux using a custom JSON-based translation catalog approach inspired by python-i18n patterns. The implementation uses only Python standard library (no external dependencies), is modular, extensible, and requires zero breaking changes to existing code.

Also applies to: 575-584

cortex/i18n/fallback_handler.py (1)

190-204: LGTM! Consider thread safety if needed.

The singleton pattern is correctly implemented with lazy initialization. For a CLI application, this implementation is appropriate.

If the application becomes multi-threaded in the future, consider adding thread safety using threading.Lock() to prevent race conditions during initialization.

I18N_IMPLEMENTATION_PLAN.md (2)

1-6: Update target languages to reflect actual implementation.

Line 5 lists 7 target languages, but the PR summary indicates 12 languages were actually implemented (adding German, Italian, Russian, Chinese Simplified, and Korean). Consider updating this planning document to reflect the actual implementation scope.

---

1078-1085: Optional: Fix markdown style issues for cleaner linting.

The markdown linter flagged several style issues:

• Lines 1080-1084: Bare URLs should be wrapped in angle brackets (e.g., <https://...>) or formatted as links
• Multiple code blocks throughout the document are missing language specifiers (e.g., lines 25, 674, 691, 707, 967, 989)

These don't affect functionality but would clean up linting warnings.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

cortex/i18n/fallback_handler.py (3)

11-15: Fix deprecated typing.Set import causing pipeline failures.

Set from typing is deprecated in Python 3.9+. Use the built-in set type for annotations instead.

🔎 Proposed fix

 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Set
+from typing import Optional

Based on past review comments and static analysis.

---

39-49: Update type annotation to use built-in set type.

Line 47 uses deprecated Set[str] annotation. Use lowercase set[str] instead for consistency with modern Python type hints.

🔎 Proposed fix

     def __init__(self, logger=None):
         """
         Initialize fallback handler.
-        
+
         Args:
             logger: Logger instance for warnings (uses module logger if None)
         """
         self.logger = logger or globals()["logger"]
-        self.missing_keys: Set[str] = set()
+        self.missing_keys: set[str] = set()
         self._session_start = datetime.now()

Based on past review comments and static analysis.

---

75-82: Update return type annotation to use built-in set.

Line 75 uses deprecated Set[str] return type. Use lowercase set[str] instead.

🔎 Proposed fix

-    def get_missing_translations(self) -> Set[str]:
+    def get_missing_translations(self) -> set[str]:
         """
         Get all missing translation keys encountered.

cortex/i18n/translator.py (1)

293-301: Remove unreachable duplicate return statement.

Lines 297-300 contain a duplicate return message statement. Line 297 returns, making lines 299-300 unreachable dead code.

🔎 Proposed fix

         except Exception as e:
             logger.debug(f"Error parsing pluralization: {e}")
         
         return message
-
-        
-        return message
-

Based on past review comments.

scripts/validate_translations.py (1)

165-185: Fix invalid return type annotation.

Line 165 uses lowercase any as a return type annotation, which is invalid Python. Use Any from the typing module (already imported on line 14).

🔎 Proposed fix

-    def _get_nested(self, catalog: Dict, key: str) -> any:
+    def _get_nested(self, catalog: Dict, key: str) -> Any:
         """
         Get value from nested dict using dot-separated key.

Based on past review comments and static analysis. As per coding guidelines, type hints are required in Python code.

cortex/translations/README.md (1)

28-28: Update German translation status to reflect actual implementation.

The status shows "Planned" but according to the PR objectives, German (de.json) is listed as one of the 12 complete languages with full translation coverage.

🔎 Proposed fix

-| de | Deutsch | Planned |
+| de | Deutsch | Complete ✓ |

Configuration used: defaults

Review profile: CHILL

Plan: Pro

cortex/i18n/translator.py (2)

11-16: Remove unused imports: locale and os.

Lines 12 and 14 import locale and os respectively, but neither is used in this module.

🔎 Proposed fix

 import json
-import locale
 import logging
-import os
 from pathlib import Path
 from typing import Any, Optional

---

296-298: Remove duplicate unreachable return statement.

Line 298 contains a duplicate return message that is unreachable because line 296 already returns. This is dead code.

🔎 Proposed fix

         except Exception as e:
             logger.debug(f"Error parsing pluralization: {e}")

         return message
-
-        return message

cortex/i18n/fallback_handler.py (1)

11-11: Remove unused csv import.

The csv module is imported but never used. The code manually constructs CSV content as strings.

🔎 Proposed fix

-import csv
 import logging
 import os
 import tempfile

docs/I18N_COMPLETE_IMPLEMENTATION.md (1)

1234-1237: Consider using a markdown link for the repository URL.

The bare URL on line 1236 is flagged by markdownlint. Consider using a proper markdown link format for consistency.

🔎 Proposed fix

-**Repository**: https://github.com/cortexlinux/cortex  
+**Repository**: [cortexlinux/cortex](https://github.com/cortexlinux/cortex)  

scripts/validate_translations.py (1)

197-197: Consider moving import re to module level.

The re import inside _check_placeholders is valid but unconventional. Moving it to the top with other imports improves readability and follows Python conventions.

🔎 Proposed fix

At module level (after line 14):

import re

Then remove line 197.

cortex/i18n/language_manager.py (2)

14-16: Unused import: Optional.

The Optional import from typing is unused since the code uses the modern str | None union syntax throughout.

🔎 Proposed fix

-from typing import Optional

---

159-165: Replace deprecated locale.getdefaultlocale() with locale.getlocale().

locale.getdefaultlocale() is deprecated as of Python 3.11 and scheduled for removal in Python 3.15. Use locale.getlocale() instead, which provides the same (language, encoding) tuple return value.

cortex/i18n/translator.py (1)

305-321: Singleton pattern has a subtle issue with language switching.

When get_translator is called with a different language, it calls set_language on the existing instance. However, if set_language fails (returns False), the function still returns the translator with potentially the wrong language expectation.

🔎 Proposed fix

 def get_translator(language: str = "en") -> Translator:
     """
     Get or create a translator instance.

     Args:
         language: Language code

     Returns:
         Translator instance
     """
     global _default_translator
     if _default_translator is None:
         _default_translator = Translator(language)
     elif language != _default_translator.language:
-        _default_translator.set_language(language)
+        if not _default_translator.set_language(language):
+            logger.warning(f"Failed to switch to '{language}', using '{_default_translator.language}'")

     return _default_translator

cortex/i18n/fallback_handler.py (1)

144-158: Consider handling Windows file permissions gracefully.

os.chmod(output_path, 0o600) on line 153 has limited effect on Windows (it can only toggle read-only). While not an error, this could be documented or wrapped in a try-except for clarity on cross-platform behavior.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

cortex/i18n/fallback_handler.py (1)

141-149: Consider using the csv module for robust escaping.

The CSV content is built manually with string operations, which doesn't handle edge cases like keys containing quotes or commas. Since the csv module is already imported, consider using csv.writer or csv.DictWriter for proper escaping and more maintainable code. Alternatively, if the manual approach is preferred, remove the unused csv import.

🔎 Proposed refactor using csv module

-        # Build CSV content
-        csv_lines = ["key,namespace"]
-
-        for key in sorted(self.missing_keys):
-            # Extract namespace from key (e.g., 'install.success' -> 'install')
-            parts = key.split(".")
-            namespace = parts[0] if len(parts) > 0 else "unknown"
-            csv_lines.append(f'"{key}","{namespace}"')
-
-        csv_content = "\n".join(csv_lines)
+        # Build CSV content
+        import io
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(["key", "namespace"])
+        
+        for key in sorted(self.missing_keys):
+            # Extract namespace from key (e.g., 'install.success' -> 'install')
+            parts = key.split(".")
+            namespace = parts[0] if len(parts) > 0 else "unknown"
+            writer.writerow([key, namespace])
+        
+        csv_content = output.getvalue()

Configuration used: defaults

Review profile: CHILL

Plan: Pro

cortex/i18n/fallback_handler.py (2)

11-11: Remove unused csv import.

The csv module is imported but never used. The CSV content is built manually using string operations (lines 140-148).

---

106-106: Fix docstring inconsistency.

The docstring states the CSV has three columns ("key, namespace, suggested_placeholder"), but the implementation only produces two columns ("key, namespace"). The example on lines 117-121 correctly shows two columns.

🔎 Proposed fix

-        Creates a CSV file with columns: key, namespace, suggested_placeholder
+        Creates a CSV file with columns: key, namespace

cortex/i18n/fallback_handler.py (2)

41-50: Consider simplifying the logger fallback.

Using globals()["logger"] is unconventional. A cleaner approach is to rename the parameter to avoid shadowing the module-level logger:

🔎 Proposed refactor

-    def __init__(self, logger=None):
+    def __init__(self, custom_logger=None):
         """
         Initialize fallback handler.

         Args:
-            logger: Logger instance for warnings (uses module logger if None)
+            custom_logger: Logger instance for warnings (uses module logger if None)
         """
-        self.logger = logger or globals()["logger"]
+        self.logger = custom_logger or logger
         self.missing_keys: set[str] = set()
         self._session_start = datetime.now()

---

144-145: Simplify redundant length check.

key.split(".") always returns a list with at least one element (even for an empty string), so len(parts) > 0 is always true.

🔎 Proposed fix

             # Extract namespace from key (e.g., 'install.success' -> 'install')
             parts = key.split(".")
-            namespace = parts[0] if len(parts) > 0 else "unknown"
+            namespace = parts[0] or "unknown"
             csv_lines.append(f'"{key}","{namespace}"')

cortex/i18n/language_manager.py (1)

98-149: Priority chain implementation is correct.

The 5-level fallback chain is well-implemented with appropriate logging at each step. The logic correctly handles invalid inputs and falls back gracefully.

Optional: More specific exception handling

Consider catching more specific exceptions at line 138:

-            except Exception as e:
+            except (AttributeError, TypeError, ValueError, OSError) as e:
                 logger.debug(f"Could not read config language: {e}")

This would make the exception handling more explicit, though the current broad catch is acceptable for ensuring robustness in a fallback chain.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

cortex/translations/it.json (1)

20-146: Multiple sections remain untranslated (English text in Italian locale file).

While the common section has been properly translated, significant portions of this file still contain English text:

• cli (lines 20-28): entirely English
• remove (lines 44-52): entirely English
• search (lines 53-63): entirely English
• prompts (lines 92-98): entirely English
• status (lines 99-107): entirely English
• wizard (lines 108-115): entirely English
• history (lines 116-124): entirely English
• notifications (lines 125-131): entirely English
• help (lines 132-139): entirely English
• demo (lines 140-146): entirely English
• config and errors: partially translated

This defeats the purpose of providing Italian localization. Users selecting Italian will see a mix of languages.

cortex/translations/ko.json (1)

20-146: Multiple sections remain untranslated (English text in Korean locale file).

While the common section is now properly translated to Korean, the same pattern of incomplete translation persists:

• cli (lines 20-28): entirely English
• remove (lines 44-52): entirely English
• search (lines 53-63): entirely English
• prompts (lines 92-98): entirely English
• status (lines 99-107): entirely English
• wizard (lines 108-115): entirely English
• history (lines 116-124): entirely English
• notifications (lines 125-131): entirely English
• help (lines 132-139): entirely English
• demo (lines 140-146): entirely English
• config and errors: partially translated

Korean users will experience inconsistent language throughout the CLI.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

cortex/validators.py (1)

125-128: Clarify shell command check logic.

The shell commands check (lines 125-128) is somewhat confusing. It checks if the name matches common shell command names but then just passes with a comment "Allow them - they are real packages". Consider either:

1. Removing this check entirely since the regex at line 113 already validates the format
2. Adding a more explicit comment explaining why shell command names like "bash" are valid package names

This is pedantic but improves code clarity.

♻️ Proposed clarification

-    # Block names that look like shell commands
-    shell_commands = ["sh", "bash", "zsh", "fish", "eval", "exec", "source"]
-    if name.lower() in shell_commands and len(name) <= 6:
-        # These are actually valid package names, but check they're exact matches
-        pass  # Allow them - they are real packages
+    # Note: Names like "bash", "sh", etc. are valid Debian package names
+    # and will pass the regex validation above. No additional checks needed.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: cortexlinux/cortex PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-11T12:03:24.071Z
Learning: Applies to **/*sandbox*.py : Implement Firejail sandboxing for package operations

cortex/cli.py (2)

47-52: Consider moving get_translator import to module level.

The local import of get_translator inside __init__ is unconventional. Unless there's a specific reason (e.g., circular import prevention), consider moving it to the module-level imports for better readability and consistency.

♻️ Proposed refactor

At the top of the file with other i18n imports:

-from cortex.i18n import LanguageManager
+from cortex.i18n import LanguageManager, get_translator

Then in __init__:

         # Initialize language manager and translator
         self.lang_manager = LanguageManager()
         detected_language = language or self.lang_manager.detect_language()
-        from cortex.i18n import get_translator
-
         self.translator = get_translator(detected_language)

---

1446-1487: Consider reusing self.lang_manager instance.

The method creates a new LanguageManager() instance instead of reusing self.lang_manager initialized in __init__. For consistency and to avoid redundant initialization, consider using the existing instance unless fresh state is specifically required.

♻️ Proposed refactor

     def _config_language(self, args: argparse.Namespace) -> int:
         """Handle language configuration."""
         config_mgr = ConfigManager()
-        lang_mgr = LanguageManager()
         new_language = getattr(args, "language_code", None)

         # Load current preferences
         prefs = config_mgr.load_preferences()
         current_lang = prefs.get("language", "en")

         if new_language:
             # Resolve language (accepts codes like 'es' or names like 'Spanish', 'Español')
-            resolved = lang_mgr.resolve_language(new_language)
+            resolved = self.lang_manager.resolve_language(new_language)
             if not resolved:
                 self._print_error(f"Language '{new_language}' is not supported")
                 cx_print("Supported languages:", "info")
-                for code, name in lang_mgr.get_available_languages().items():
+                for code, name in self.lang_manager.get_available_languages().items():
                     console.print(f"  [green]{code}[/green] - {name}")
                 return 1

             # Save preference
             prefs["language"] = resolved
             config_mgr.save_preferences(prefs)

-            lang_name = lang_mgr.get_language_name(resolved)
+            lang_name = self.lang_manager.get_language_name(resolved)
             cx_print(f"✓ Language set to {lang_name} ({resolved})", "success")
             cx_print("This will be used for all future Cortex commands.", "info")
             return 0
         else:
             # Show current language and available options
-            lang_name = lang_mgr.get_language_name(current_lang)
+            lang_name = self.lang_manager.get_language_name(current_lang)
             cx_header("Language Configuration")
             console.print(f"  Current language: [green]{lang_name}[/green] ({current_lang})")
             console.print()
             console.print("[bold]Available languages:[/bold]")
-            for code, name in sorted(lang_mgr.get_available_languages().items()):
+            for code, name in sorted(self.lang_manager.get_available_languages().items()):
                 marker = " [cyan]◄[/cyan]" if code == current_lang else ""
                 console.print(f"  [green]{code}[/green] - {name}{marker}")
             console.print()
             cx_print("Set language: cortex config language <code>", "info")
             cx_print("Example: cortex config language es", "info")
             return 0

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: cortexlinux/cortex PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-11T12:03:24.071Z
Learning: Applies to **/*.py : Docstrings required for all public APIs

cortex/cli.py (1)

1446-1487: Consider adding error handling for preference saving.

While the current implementation allows exceptions to propagate to the main error handler, catching RuntimeError from save_preferences() (line 1468) would enable a more specific error message for users.

♻️ Optional improvement

         # Save preference
         prefs["language"] = resolved
-        config_mgr.save_preferences(prefs)
+        try:
+            config_mgr.save_preferences(prefs)
+        except RuntimeError as e:
+            self._print_error(f"Failed to save language preference: {e}")
+            return 1
 
         lang_name = lang_mgr.get_language_name(resolved)

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: cortexlinux/cortex PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-11T12:03:24.071Z
Learning: Applies to **/*.py : Docstrings required for all public APIs